[workspaces] Don't use a clone for the window drag actor

Using a clone for the drag actor causes the animation into
the final position not to work as expected; instead use
the newly added DND parameters to change the original
drag actors size and opacity. (This reverts the change in
011db9f).

Since we are using the original actor, we have to be careful
not to change it during the drag, so don't actually position
dragged window actors in Workspace.positionWindows().

https://bugzilla.gnome.org/show_bug.cgi?id=613367

diff --git a/js/ui/workspace.js b/js/ui/workspace.js
index 8b570a45c4053c11f9661b86c14358d7e8d5f4f2..9894935373d792ae9266567e7f2adba8371627b3 100644 (file)
--- a/js/ui/workspace.js
+++ b/js/ui/workspace.js
@@ -128,53 +128,20 @@ WindowClone.prototype = {
                            Lang.bind(this, this._onLeave));
         this._havePointer = false;
 
-        this._draggable = DND.makeDraggable(this.actor);
+        this._draggable = DND.makeDraggable(this.actor,
+                                            { dragActorMaxSize: WINDOW_DND_SIZE,
+                                              dragActorOpacity: DRAGGING_WINDOW_OPACITY });
         this._draggable.connect('drag-begin', Lang.bind(this, this._onDragBegin));
         this._draggable.connect('drag-end', Lang.bind(this, this._onDragEnd));
-        this._inDrag = false;
+        this.inDrag = false;
 
         this._zooming = false;
         this._selected = false;
     },
 
-    getDragActorSource: function() {
-        return this.actor;
-    },
-
-    getDragActor: function(x, y) {
-        // We want to shrink the window down to at most THUMBNAIL_SIZE in one direction,
-        // but animate that transition.  The way we do this is to compute our final
-        // width/height, and set that on the Clone.  The clone itself will then scale
-        // the source.  But to animate, we need to compute a scale which will get us
-        // back to the original size, and then animate down to a scale of 1.
-        let scale = Math.min(WINDOW_DND_SIZE / this.realWindow.width, WINDOW_DND_SIZE / this.realWindow.height);
-        let [transformedX, transformedY] = this.actor.get_transformed_position();
-        let [transformedWidth, transformedHeight] = this.actor.get_transformed_size();
-        let xOffset = (x - transformedX) * scale;
-        let yOffset = (y - transformedY) * scale;
-        let targetWidth = this.realWindow.width * scale;
-        let targetHeight = this.realWindow.height * scale;
-        let inverseScale;
-        if (targetWidth < transformedWidth)
-            inverseScale = transformedWidth / targetWidth;
-        else
-            inverseScale = 1;
-        let actor = new Clutter.Clone({ source: this.realWindow,
-                                        width: targetWidth,
-                                        height: targetHeight,
-                                        opacity: DRAGGING_WINDOW_OPACITY });
-        actor.set_scale_full(inverseScale, inverseScale, xOffset, yOffset);
-        Tweener.addTween(actor, { time: Overview.ANIMATION_TIME,
-                                  transition: "easeOutQuad",
-                                  scale_x: 1,
-                                  scale_y: 1 });
-        actor._delegate = this;
-        return actor;
-    },
-
     setStackAbove: function (actor) {
         this._stackAbove = actor;
-        if (this._inDrag || this._zooming)
+        if (this.inDrag || this._zooming)
             // We'll fix up the stack after the drag/zooming
             return;
         this.actor.raise(this._stackAbove);
@@ -204,9 +171,9 @@ WindowClone.prototype = {
         if (this._zoomLightbox)
             this._zoomLightbox.destroy();
 
-        if (this._inDrag) {
+        if (this.inDrag) {
             this.emit('drag-end');
-            this._inDrag = false;
+            this.inDrag = false;
         }
 
         this.disconnectAll();
@@ -215,7 +182,7 @@ WindowClone.prototype = {
     _onEnter: function (actor, event) {
         // If the user drags faster than we can follow, he'll end up
         // leaving the window temporarily and then re-entering it
-        if (this._inDrag)
+        if (this.inDrag)
             return;
 
         this._havePointer = true;
@@ -224,7 +191,7 @@ WindowClone.prototype = {
     _onLeave: function (actor, event) {
         // If the user drags faster than we can follow, he'll end up
         // leaving the window temporarily and then re-entering it
-        if (this._inDrag)
+        if (this.inDrag)
             return;
 
         this._havePointer = false;
@@ -324,14 +291,12 @@ WindowClone.prototype = {
     },
 
     _onDragBegin : function (draggable, time) {
-        this.actor.hide();
-        this._inDrag = true;
+        this.inDrag = true;
         this.emit('drag-begin');
     },
 
     _onDragEnd : function (draggable, time, snapback) {
-        this._inDrag = false;
-        this.actor.show();
+        this.inDrag = false;
 
         // Most likely, the clone is going to move away from the
         // pointer now. But that won't cause a leave-event, so
@@ -1135,6 +1100,11 @@ Workspace.prototype = {
             let mainIndex = this._lookupIndex(metaWindow);
             let overlay = this._windowOverlays[mainIndex];
 
+            // Positioning a window currently being dragged must be avoided;
+            // we'll just leave a blank spot in the layout for it.
+            if (clone.inDrag)
+                continue;
+
             let [x, y, scale] = this._computeWindowRelativeLayout(metaWindow, slot);
 
             if (overlay)